home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 365_01 / blk.c < prev    next >
C/C++ Source or Header  |  1992-04-06  |  10KB  |  470 lines
  1. /* blk.c */
  2.  
  3. /* Author:
  4.  *    Steve Kirkendall
  5.  *    14407 SW Teal Blvd. #C
  6.  *    Beaverton, OR 97005
  7.  *    kirkenda@cs.pdx.edu
  8.  */
  9.  
  10.  
  11. /* This file contains the functions that get/put blocks from the temp file.
  12.  * It also contains the "do" and "undo" functions.
  13.  */
  14.  
  15. #include "config.h"
  16. #include "vi.h"
  17.  
  18. #ifndef NBUFS
  19. # define NBUFS    5        /* must be at least 3 -- more is better */
  20. #endif
  21.  
  22.  
  23. /*------------------------------------------------------------------------*/
  24.  
  25. BLK        hdr;        /* buffer for the header block */
  26.  
  27. static int    b4cnt;        /* used to count context of beforedo/afterdo */
  28. static struct _blkbuf
  29. {
  30.     BLK        buf;        /* contents of a text block */
  31.     unsigned short    logical;    /* logical block number */
  32.     int        dirty;        /* must the buffer be rewritten? */
  33. }
  34.         blk[NBUFS],    /* buffers for text[?] blocks */
  35.         *toonew,    /* buffer which shouldn't be recycled yet */
  36.         *newtoo,    /* another buffer which should be recycled */
  37.         *recycle = blk;    /* next block to be recycled */
  38.  
  39.  
  40.  
  41.  
  42.  
  43. /* This function wipes out all buffers */
  44. void blkinit()
  45. {
  46.     int    i;
  47.  
  48.     for (i = 0; i < NBUFS; i++)
  49.     {
  50.         blk[i].logical = 0;
  51.         blk[i].dirty = FALSE;
  52.     }
  53.     for (i = 0; i < MAXBLKS; i++)
  54.     {
  55.         hdr.n[i] = 0;
  56.     }
  57. }
  58.  
  59. /* This function allocates a buffer and fills it with a given block's text */
  60. BLK *blkget(logical)
  61.     int    logical;    /* logical block number to fetch */
  62. {
  63.     REG struct _blkbuf    *this;    /* used to step through blk[] */
  64.     REG int    i;
  65.  
  66.     /* if logical is 0, just return the hdr buffer */
  67.     if (logical == 0)
  68.     {
  69.         return &hdr;
  70.     }
  71.  
  72.     /* see if we have that block in mem already */
  73.     for (this = blk; this < &blk[NBUFS]; this++)
  74.     {
  75.         if (this->logical == logical)
  76.         {
  77.             newtoo = toonew;
  78.             toonew = this;
  79.             return &this->buf;
  80.         }
  81.     }
  82.  
  83.     /* choose a block to be recycled */
  84.     do
  85.     {
  86.         this = recycle++;
  87.         if (recycle == &blk[NBUFS])
  88.         {
  89.             recycle = blk;
  90.         }
  91.     } while (this == toonew || this == newtoo);
  92.  
  93.     /* if it contains a block, flush that block */
  94.     blkflush(this);
  95.  
  96.     /* fill this buffer with the desired block */
  97.     this->logical = logical;
  98.     if (hdr.n[logical])
  99.     {
  100.         /* it has been used before - fill it from tmp file */
  101.         lseek(tmpfd, (long)hdr.n[logical] * (long)BLKSIZE, 0);
  102.         if (read(tmpfd, this->buf.c, (unsigned)BLKSIZE) != BLKSIZE)
  103.         {
  104.             msg("Error reading back from tmp file!");
  105.         }
  106.     }
  107.     else
  108.     {
  109.         /* it is new - zero it */
  110.         for (i = 0; i < BLKSIZE; i++)
  111.         {
  112.             this->buf.c[i] = 0;
  113.         }
  114.     }
  115.  
  116.     /* This isn't really a change, but it does potentially invalidate
  117.      * the kinds of shortcuts that the "changes" variable is supposed
  118.      * to protect us from... so count it as a change.
  119.      */
  120.     changes++;
  121.  
  122.     /* mark it as being "not dirty" */
  123.     this->dirty = 0;
  124.  
  125.     /* return it */
  126.     newtoo = toonew;
  127.     toonew = this;
  128.     return &this->buf;
  129. }
  130.  
  131.  
  132.  
  133. /* This function writes a block out to the temporary file */
  134. void blkflush(this)
  135.     REG struct _blkbuf    *this;    /* the buffer to flush */
  136. {
  137.     long        seekpos;    /* seek position of the new block */
  138.     unsigned short    physical;    /* physical block number */
  139.  
  140.     /* if its empty (an orphan blkadd() maybe?) then make it dirty */
  141.     if (this->logical && !*this->buf.c)
  142.     {
  143.         blkdirty(&this->buf);
  144.     }
  145.  
  146.     /* if it's an empty buffer or a clean version is on disk, quit */
  147.     if (!this->logical || hdr.n[this->logical] && !this->dirty)
  148.     {
  149.         return;
  150.     }
  151.  
  152.     /* find a free place in the file */
  153. #ifndef NO_RECYCLE
  154.     seekpos = allocate();
  155.     lseek(tmpfd, seekpos, 0);
  156. #else
  157.     seekpos = lseek(tmpfd, 0L, 2);
  158. #endif
  159.     physical = seekpos / BLKSIZE;
  160.  
  161.     /* put the block there */
  162.     if (write(tmpfd, this->buf.c, (unsigned)BLKSIZE) != BLKSIZE)
  163.     {
  164.         msg("Trouble writing to tmp file");
  165.     }
  166.     this->dirty = FALSE;
  167.  
  168.     /* update the header so it knows we put it there */
  169.     hdr.n[this->logical] = physical;
  170. }
  171.  
  172.  
  173. /* This function sets a block's "dirty" flag or deletes empty blocks */
  174. void blkdirty(bp)
  175.     BLK    *bp;    /* buffer returned by blkget() */
  176. {
  177.     REG int        i, j;
  178.     REG char    *scan;
  179.     REG int        k;
  180.  
  181.     /* find the buffer */
  182.     for (i = 0; i < NBUFS && bp != &blk[i].buf; i++)
  183.     {
  184.     }
  185. #ifdef DEBUG
  186.     if (i >= NBUFS)
  187.     {
  188.         msg("blkdirty() called with unknown buffer at 0x%lx", bp);
  189.         return;
  190.     }
  191.     if (blk[i].logical == 0)
  192.     {
  193.         msg("blkdirty called with freed buffer");
  194.         return;
  195.     }
  196. #endif
  197.  
  198.     /* if this block ends with line# INFINITY, then it must have been
  199.      * allocated unnecessarily during tmpstart().  Forget it.
  200.      */
  201.     if (lnum[blk[i].logical] == INFINITY)
  202.     {
  203. #ifdef DEBUG
  204.         if (blk[i].buf.c[0])
  205.         {
  206.             msg("bkldirty called with non-empty extra BLK");
  207.         }
  208. #endif
  209.         blk[i].logical = 0;
  210.         blk[i].dirty = FALSE;
  211.         return;
  212.     }
  213.  
  214.     /* count lines in this block */
  215.     for (j = 0, scan = bp->c; *scan && scan < bp->c + BLKSIZE; scan++)
  216.     {
  217.         if (*scan == '\n')
  218.         {
  219.             j++;
  220.         }
  221.     }
  222.  
  223.     /* adjust lnum, if necessary */
  224.     k = blk[i].logical;
  225.     j += (lnum[k - 1] - lnum[k]);
  226.     if (j != 0)
  227.     {
  228.         nlines += j;
  229.         while (k < MAXBLKS && lnum[k] != INFINITY)
  230.         {
  231.             lnum[k++] += j;
  232.         }
  233.     }
  234.  
  235.     /* if it still has text, mark it as dirty */
  236.     if (*bp->c)
  237.     {
  238.         blk[i].dirty = TRUE;
  239.     }
  240.     else /* empty block, so delete it */
  241.     {
  242.         /* adjust the cache */
  243.         k = blk[i].logical;
  244.         for (j = 0; j < NBUFS; j++)
  245.         {
  246.             if (blk[j].logical >= k)
  247.             {
  248.                 blk[j].logical--;
  249.             }
  250.         }
  251.  
  252.         /* delete it from hdr.n[] and lnum[] */
  253.         blk[i].logical = 0;
  254.         blk[i].dirty = FALSE;
  255.         while (k < MAXBLKS - 1)
  256.         {
  257.             hdr.n[k] = hdr.n[k + 1];
  258.             lnum[k] = lnum[k + 1];
  259.             k++;
  260.         }
  261.         hdr.n[MAXBLKS - 1] = 0;
  262.         lnum[MAXBLKS - 1] = INFINITY;
  263.     }
  264. }
  265.  
  266.  
  267. /* insert a new block into hdr, and adjust the cache */
  268. BLK *blkadd(logical)
  269.     int    logical;    /* where to insert the new block */
  270. {
  271.     REG int    i;
  272.  
  273.     /* adjust hdr and lnum[] */
  274.     for (i = MAXBLKS - 1; i > logical; i--)
  275.     {
  276.         hdr.n[i] = hdr.n[i - 1];
  277.         lnum[i] = lnum[i - 1];
  278.     }
  279.     hdr.n[logical] = 0;
  280.     lnum[logical] = lnum[logical - 1];
  281.  
  282.     /* adjust the cache */
  283.     for (i = 0; i < NBUFS; i++)
  284.     {
  285.         if (blk[i].logical >= logical)
  286.         {
  287.             blk[i].logical++;
  288.         }
  289.     }
  290.  
  291.     /* return the new block, via blkget() */
  292.     return blkget(logical);
  293. }
  294.  
  295.  
  296. /* This function forces all dirty blocks out to disk */
  297. void blksync()
  298. {
  299.     int    i;
  300.  
  301.     for (i = 0; i < NBUFS; i++)
  302.     {
  303.         /* blk[i].dirty = TRUE; */
  304.         blkflush(&blk[i]);
  305.     }
  306.     if (*o_sync)
  307.     {
  308.         sync();
  309.     }
  310. }
  311.  
  312. /*------------------------------------------------------------------------*/
  313.  
  314. static MARK    undocurs;    /* where the cursor should go if undone */
  315. static long    oldnlines;
  316. static long    oldlnum[MAXBLKS];
  317.  
  318.  
  319. /* This function should be called before each command that changes the text.
  320.  * It defines the state that undo() will reset the file to.
  321.  */
  322. void beforedo(forundo)
  323.     int        forundo;    /* boolean: is this for an undo? */
  324. {
  325.     REG int        i;
  326.     REG long    l;
  327.  
  328.     /* if this is a nested call to beforedo, quit! Use larger context */
  329.     if (b4cnt++ > 0)
  330.     {
  331.         return;
  332.     }
  333.  
  334.     /* force all block buffers to disk */
  335.     blksync();
  336.  
  337. #ifndef NO_RECYCLE
  338.     /* perform garbage collection on blocks from tmp file */
  339.     garbage();
  340. #endif
  341.  
  342.     /* force the header out to disk */
  343.     lseek(tmpfd, 0L, 0);
  344.     if (write(tmpfd, hdr.c, (unsigned)BLKSIZE) != BLKSIZE)
  345.     {
  346.         msg("Trouble writing header to tmp file ");
  347.     }
  348.  
  349.     /* copy or swap oldnlines <--> nlines, oldlnum <--> lnum */
  350.     if (forundo)
  351.     {
  352.         for (i = 0; i < MAXBLKS; i++)
  353.         {
  354.             l = lnum[i];
  355.             lnum[i] = oldlnum[i];
  356.             oldlnum[i] = l;
  357.         }
  358.         l = nlines;
  359.         nlines = oldnlines;
  360.         oldnlines = l;
  361.     }
  362.     else
  363.     {
  364.         for (i = 0; i < MAXBLKS; i++)
  365.         {
  366.             oldlnum[i] = lnum[i];
  367.         }
  368.         oldnlines = nlines;
  369.     }
  370.  
  371.     /* save the cursor position */
  372.     undocurs = cursor;
  373.  
  374.     /* upon return, the calling function continues and makes changes... */
  375. }
  376.  
  377. /* This function marks the end of a (nested?) change to the file */
  378. void afterdo()
  379. {
  380.     if (--b4cnt)
  381.     {
  382.         /* after abortdo(), b4cnt may decribe nested beforedo/afterdo
  383.          * pairs incorrectly.  If it is decremented to often, then
  384.          * keep b4cnt sane but don't do anything else.
  385.          */
  386.         if (b4cnt < 0)
  387.             b4cnt = 0;
  388.  
  389.         return;
  390.     }
  391.  
  392.     /* make sure the cursor wasn't left stranded in deleted text */
  393.     if (markline(cursor) > nlines)
  394.     {
  395.         cursor = MARK_LAST;
  396.     }
  397.     /* NOTE: it is still possible that markidx(cursor) is after the
  398.      * end of a line, so the Vi mode will have to take care of that
  399.      * itself */
  400.  
  401.     /* if a significant change has been made to this file, then set the
  402.      * MODIFIED flag.
  403.      */
  404.     if (significant)
  405.     {
  406.         setflag(file, MODIFIED);
  407.         setflag(file, UNDOABLE);
  408.     }    
  409. }
  410.  
  411. /* This function cuts short the current set of changes.  It is called after
  412.  * a SIGINT.
  413.  */
  414. void abortdo()
  415. {
  416.     /* finish the operation immediately. */
  417.     if (b4cnt > 0)
  418.     {
  419.         b4cnt = 1;
  420.         afterdo();
  421.     }
  422.  
  423.     /* in visual mode, the screen is probably screwed up */
  424.     if (mode == MODE_COLON)
  425.     {
  426.         mode = MODE_VI;
  427.     }
  428.     if (mode == MODE_VI)
  429.     {
  430.         redraw(MARK_UNSET, FALSE);
  431.     }
  432. }
  433.  
  434. /* This function discards all changes made since the last call to beforedo() */
  435. int undo()
  436. {
  437.     BLK        oldhdr;
  438.  
  439.     /* if beforedo() has never been run, fail */
  440.     if (!tstflag(file, UNDOABLE))
  441.     {
  442.         msg("You haven't modified this file yet.");
  443.         return FALSE;
  444.     }
  445.  
  446.     /* read the old header form the tmp file */
  447.     lseek(tmpfd, 0L, 0);
  448.     if (read(tmpfd, oldhdr.c, (unsigned)BLKSIZE) != BLKSIZE)
  449.     {
  450.         msg("Trouble rereading the old header from tmp file");
  451.     }
  452.  
  453.     /* "do" the changed version, so we can undo the "undo" */
  454.     cursor = undocurs;
  455.     beforedo(TRUE);
  456.     afterdo();
  457.  
  458.     /* wipe out the block buffers - we can't assume they're correct */
  459.     blkinit();
  460.  
  461.     /* use the old header -- and therefore the old text blocks */
  462.     hdr = oldhdr;
  463.  
  464.     /* This is a change */
  465.     significant = TRUE;
  466.     changes++;
  467.  
  468.     return TRUE;
  469. }
  470.